home *** CD-ROM | disk | FTP | other *** search
/ PC World 2005 December / PCWorld_2005-12_cd.bin / software / temacd / tiny / tpf-6[1].5.126.exe / Tiny Firewall 2005.msi / webui.dll / WS / WSN-SDBFNCS.JS < prev    next >
Encoding:
Text (UTF-16)  |  2005-08-17  |  74.1 KB  |  1,178 lines
  1. /*//////////////////////////////////////////////////////////////////////
  2. Filename:          wsn-sdbfncs.js
  3. Company Name:      Computer Associates International, Inc.
  4. Legal Copyright: Copyright (c) Computer Associates International, Inc.
  5. Author:          Ales Novak
  6. Product:          Tiny Firewall
  7. Description:      javascript code to access active db through XMLSecDBParser COM iface
  8. ///////////////////////////////////////////////////////////////////////*/
  9.  
  10. // requires sdb-consts.js + sdb-msgs.js
  11.  
  12. ///////////////////////////////////////////////////////////////////////
  13. // getRuleList - internal function
  14. function getRuleList( bUseClientParser )
  15. {
  16.     return (parseBoolean(bUseClientParser) != 0) ? external.ClientParser(XM_SBX).RuleList : external.ServerParser(XM_SBX).RuleList;
  17. }
  18.  
  19. ///////////////////////////////////////////////////////////////////////
  20. // getDefinitionList - internal function
  21. function getDefinitionList( bUseClientParser )
  22. {
  23.     return (parseBoolean(bUseClientParser) != 0) ? external.ClientParser(XM_SBX).DefinitionList : external.ServerParser(XM_SBX).DefinitionList;
  24. }
  25.  
  26. ///////////////////////////////////////////////////////////////////////
  27. // getExceptionList - internal function
  28. function getAppExceptionList()
  29. {
  30.     return external.ServerParser(XM_SBX).AppExceptionList;
  31. }
  32.  
  33. function WS_isDefinitionEmpty( strDefID, bUseClientParser)
  34. {
  35.     var definitionList = getDefinitionList( bUseClientParser );
  36.  
  37.     try
  38.     {
  39.         var oDef = definitionList.Get( strDefID );
  40.         
  41.         var itemEnum = new Enumerator(oDef.ItemList);
  42.         itemEnum.moveFirst();
  43.         
  44.         if ( itemEnum.item() )
  45.             return false;
  46.     }
  47.     catch (e)
  48.     {
  49.     }
  50.     
  51.     return true;
  52. }
  53.  
  54.  
  55. ///////////////////////////////////////////////////////////////////////
  56. // getGlobalOptionsList - internal function
  57. function getGlobalOptions()
  58. {
  59.     return external.ServerParser(XM_SBX).GlobalOptions;
  60. }
  61.  
  62. function WS_getRule( strRuleID, bUseClientParser)
  63. {
  64.     try {
  65.         var ruleList = getRuleList( bUseClientParser );
  66.         
  67.         return ruleList.Get(strRuleID);
  68.     } 
  69.     catch(e)
  70.     {
  71.         return null;
  72.     }
  73. }
  74.  
  75. //////////////// Easy rules support /////////////////////////////
  76. function WS_easyRulesEnabled( eObjType )
  77. {
  78.     var eList = new Enumerator( getRuleList( false ) )
  79.     eList.moveFirst();
  80.  
  81.     while (!eList.atEnd())
  82.     {
  83.         var rule = eList.item();
  84.         
  85.         if ( (rule.ObjectType == eObjType) && WS_isEasyRule(rule.Priority==PRIOR_HIGH, rule.Preferred) )
  86.         {
  87.             return rule.Enabled;
  88.         }
  89.             
  90.         eList.moveNext();
  91.     }
  92.  
  93.     return true;
  94. }
  95.  
  96. function WS_isEasyRuleByID( strRuleID, bUseClientParser )
  97. {
  98.     var rule = WS_getRule( strRuleID, bUseClientParser);
  99.     
  100.     if ( rule )
  101.     {
  102.         return WS_isEasyRule(rule.Priority == PRIOR_HIGH, rule.Preferred);
  103.     }
  104.     
  105.     return false;
  106. }
  107.  
  108. // nopreferred low priority or preferred high priorit
  109. function WS_isEasyRule(bHighPriority, bPreferred)
  110. {
  111.     return ((!bHighPriority && !bPreferred ) || (bHighPriority && bPreferred ));
  112. }
  113.  
  114. ///////////////////////////////////////////////////////////////////////
  115. // WS_SwitchEasyRule
  116. function WS_SwitchEasyRule( strRuleID )
  117. {
  118.     try {
  119.         
  120.         var ruleList = getRuleList( false );
  121.         
  122.         var rule = ruleList.Get(strRuleID);
  123.         if (rule)
  124.         {
  125.             var bEasy = WS_isEasyRule(rule.Priority == PRIOR_HIGH, rule.Preferred);
  126.             
  127.             if ( !bEasy )
  128.             {
  129.                 rule.Enabled = WS_easyRulesEnabled( rule.ObjectType );
  130.             }
  131.             rule.Preferred = !rule.Preferred;
  132.         }
  133.  
  134.         saveWSChanges(false);
  135.         
  136.         return SUCCESS;
  137.     } catch(e){
  138.         return ErrorHandler( ERR_EDIT_FW_RULE_FAILED, STR_EDIT_FW_RULE_FAILED );
  139.     }
  140. }
  141.  
  142.  
  143. ///////////////////////////////////////////////////////////////////////
  144. // saveWSChanges - internal function
  145. function saveWSChanges( bUseClientParser, bAvoidSavingSDB )
  146. {
  147.     if (!bAvoidSavingSDB || !parseBoolean(bAvoidSavingSDB))
  148.     {
  149.         var parser;
  150.         if ( parseBoolean( bUseClientParser ) == 0)
  151.             parser = external.ServerParser(XM_SBX);
  152.         else
  153.             parser = external.ClientParser(XM_SBX);
  154.  
  155.         parser.Save(parser.FilePath); 
  156.     }
  157. }
  158.  
  159. ///////////////////////////////////////////////////////////////////////
  160. // WS_AddFileRule
  161. function WS_AddFileRule( strPathID, strPath, strAppGroupID, strAppLabel, eAppAccountType, 
  162.     arRead, alRead, arCreate, alCreate, arWrite, alWrite, arDelete, alDelete,
  163.     strRuleDescription, bHighPriority, bUseClientParser, strUsers, strDayTimeID, strDayTime, 
  164.     iOutConditionAND, iOutConditionOR )
  165. {
  166.     return WS_AddRuleImpl( strPathID, strPath, OT_FILE, false, strAppGroupID, strAppLabel, eAppAccountType, 
  167.         AT_FILE_READ, arRead, alRead, AT_FILE_CREATE, arCreate, alCreate, AT_FILE_WRITE, arWrite, alWrite, AT_FILE_DELETE, arDelete, alDelete,
  168.         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  169.         strRuleDescription, bHighPriority, false, false, bUseClientParser, strUsers, strDayTimeID, strDayTime, iOutConditionAND, iOutConditionOR );
  170. }
  171.  
  172. ///////////////////////////////////////////////////////////////////////
  173. // WS_AddRegistryRule
  174. function WS_AddRegistryRule( strPathID, strPath, strAppGroupID, strAppLabel, eAppAccountType, 
  175.     arRead, alRead, arCreate, alCreate, arWrite, alWrite, arDelete, alDelete,
  176.     strRuleDescription, bHighPriority, bUseClientParser, strUsers, strDayTimeID, strDayTime, 
  177.     iOutConditionAND, iOutConditionOR )
  178. {
  179.     return WS_AddRuleImpl( strPathID, strPath, OT_REGISTRY, false, strAppGroupID, strAppLabel, eAppAccountType, 
  180.         AT_KEY_READ, arRead, alRead, AT_KEY_CREATE, arCreate, alCreate, AT_KEY_WRITE, arWrite, alWrite, AT_KEY_DELETE, arDelete, alDelete,
  181.         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  182.         strRuleDescription, bHighPriority, false, false, bUseClientParser, strUsers, strDayTimeID, strDayTime, iOutConditionAND, iOutConditionOR );
  183. }
  184.  
  185. ///////////////////////////////////////////////////////////////////////
  186. // WS_AddSpawningRule
  187. function WS_AddSpawningRule( strChildGroupID, strChildLabel, strParentGroupID, strParentLabel, eAppAccountType, 
  188.     arSpawn, alSpawn, arChildOwnSecurity, alChildOwnSecurity, 
  189.     strRuleDescription, bHighPriority, bUseClientParser, strUsers, strDayTimeID, strDayTime, 
  190.     iOutConditionAND, iOutConditionOR )
  191. {
  192.     return WS_AddRuleImpl( strChildGroupID, strChildLabel, OT_SPAWNING, false, strParentGroupID, strParentLabel, eAppAccountType, 
  193.         AT_PROCESS_SPAWN_ENABLED, arSpawn, alSpawn, AT_PROCESS_SPAWN_RUN_UNDER_OWN_SECURITY, arChildOwnSecurity, alChildOwnSecurity,  0, 0, 0,  0, 0, 0,
  194.         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  195.         strRuleDescription, bHighPriority, false, false, bUseClientParser, strUsers, strDayTimeID, strDayTime, iOutConditionAND, iOutConditionOR );
  196. }
  197.  
  198. ///////////////////////////////////////////////////////////////////////
  199. // WS_AddLoadDllRule
  200. function WS_AddLoadDllRule( strChildGroupID, strChildLabel, bChildIsDll, strParentGroupID, strParentLabel, eAppAccountType, 
  201.     arLoad, alLoad, 
  202.     strRuleDescription, bHighPriority, bUseClientParser, strUsers, strDayTimeID, strDayTime, 
  203.     iOutConditionAND, iOutConditionOR )
  204. {
  205.     return WS_AddRuleImpl( strChildGroupID, strChildLabel, OT_SPAWN_DLL, bChildIsDll, strParentGroupID, strParentLabel, eAppAccountType, 
  206.         AT_SPAWNDLL_LOAD_DLL, arLoad, alLoad, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  207.         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  208.         strRuleDescription, bHighPriority, false, false, bUseClientParser, strUsers, strDayTimeID, strDayTime, iOutConditionAND, iOutConditionOR );
  209. }
  210.  
  211. ///////////////////////////////////////////////////////////////////////
  212. // WS_AddDeviceRule
  213. function WS_AddDeviceRule( strDevice, strAppGroupID, strAppLabel, eAppAccountType, 
  214.     arOpen, alOpen, arRead, alRead, arWrite, alWrite, arIoctl, alIoctl, arDangIoctl, arDangIoctl,
  215.     strRuleDescription )
  216. {
  217.     return WS_AddRuleImpl( "", strPath, OT_DEVICE, false, strAppGroupID, strAppLabel, eAppAccountType, 
  218.         AT_DEVICE_OPEN, arOpen, alOpen, AT_DEVICE_READ, arRead, alRead, AT_DEVICE_WRITE, arWrite, alWrite, AT_DEVICE_IOCTL, arIoctl, alIoctl,
  219.         AT_DEVICE_DANGEROUS_IOCTL, arDangIoctl, arDangIoctl, 
  220.         0, 0, 0, 0, 0, 0, 0, 0, 0,
  221.         strRuleDescription );
  222. }
  223.  
  224. ///////////////////////////////////////////////////////////////////////
  225. // WS_AddAccesDescriptorToRuleImpl - do not use it directly from HTML
  226. function WS_AddAccesDescriptorToRuleImpl( rule, iAccessType, iAccessResult, iAuditLevel )
  227. {
  228.     var accessDescriptor = rule.AccessDescriptorList.CreateAccessDescriptor();
  229.     
  230.     accessDescriptor.AccessType = parseInt(iAccessType); 
  231.     accessDescriptor.AuditLevel = iAuditLevel ? parseInt(iAuditLevel) : 0; 
  232.     accessDescriptor.AccessResult = iAccessResult ? parseInt(iAccessResult) : 0; 
  233.     
  234.     rule.AccessDescriptorList.Insert(accessDescriptor);
  235. }
  236.  
  237. ///////////////////////////////////////////////////////////////////////
  238. // fillRuleImpl - internal function
  239. //
  240. function fillRuleImpl( rule, 
  241.     strObjectID, strObject, eObjectType, bIsDllObject, 
  242.     strAppGroupID, strAppLabel, eAppAccountType, 
  243.     iAccessType1, iAccessResult1, iAuditLevel1,  
  244.     iAccessType2, iAccessResult2, iAuditLevel2,  
  245.     iAccessType3, iAccessResult3, iAuditLevel3,  
  246.     iAccessType4, iAccessResult4, iAuditLevel4,  
  247.     iAccessType5, iAccessResult5, iAuditLevel5,  
  248.     iAccessType6, iAccessResult6, iAuditLevel6,  
  249.     iAccessType7, iAccessResult7, iAuditLevel7,  
  250.     iAccessType8, iAccessResult8, iAuditLevel8,  
  251.     strRuleDescription, bHighPriority, bPreferred, bDisabled, bUseClientParser, 
  252.     strUsers, strDayTimeID, strDayTime, iOutConditionAND, iOutConditionOR, eOSVersion )
  253. {
  254.     rule.ObjectType = parseInt(eObjectType);
  255.     rule.PathType = strObjectID ? RT_DEFINITION : RT_DIRECT;
  256.     rule.Path = strObjectID ? strObjectID : (strObject ? strObject : "");
  257.     rule.DllObject = parseBoolean(bIsDllObject);
  258.     
  259.     rule.AccessDescriptorList.Clear();
  260.     
  261.     // fill the access type list
  262.     if (iAccessType1 && parseInt(iAccessType1))
  263.         WS_AddAccesDescriptorToRuleImpl( rule, iAccessType1, iAccessResult1, iAuditLevel1 );
  264.     if (iAccessType2 && parseInt(iAccessType2))
  265.         WS_AddAccesDescriptorToRuleImpl( rule, iAccessType2, iAccessResult2, iAuditLevel2 );
  266.     if (iAccessType3 && parseInt(iAccessType3))
  267.         WS_AddAccesDescriptorToRuleImpl( rule, iAccessType3, iAccessResult3, iAuditLevel3 );
  268.     if (iAccessType4 && parseInt(iAccessType4))
  269.         WS_AddAccesDescriptorToRuleImpl( rule, iAccessType4, iAccessResult4, iAuditLevel4 );
  270.     if (iAccessType5 && parseInt(iAccessType5))
  271.         WS_AddAccesDescriptorToRuleImpl( rule, iAccessType5, iAccessResult5, iAuditLevel5 );
  272.     if (iAccessType6 && parseInt(iAccessType6))
  273.         WS_AddAccesDescriptorToRuleImpl( rule, iAccessType6, iAccessResult6, iAuditLevel6 );
  274.     if (iAccessType7 && parseInt(iAccessType7))
  275.         WS_AddAccesDescriptorToRuleImpl( rule, iAccessType7, iAccessResult7, iAuditLevel7 );
  276.     if (iAccessType8 && parseInt(iAccessType8))
  277.         WS_AddAccesDescriptorToRuleImpl( rule, iAccessType8, iAccessResult8, iAuditLevel8 );
  278.  
  279.     rule.Application = strAppGroupID ? strAppGroupID : strAppLabel;
  280.     rule.AppType = strAppGroupID ? AT_DEFINITION : AT_LABEL;
  281.     rule.Priority = PRIOR_NORMAL;
  282.     if (!parseBoolean(bUseClientParser))
  283.         rule.Priority = parseBoolean(bHighPriority) ? PRIOR_HIGH : PRIOR_LOW; 
  284.     rule.Description = strRuleDescription ? strRuleDescription : "";
  285.         
  286.     //rule.Account = parseBoolean(bIsSystemAccount) ? RA_SYSTEM : RA_USER; 
  287.     rule.Account = eAppAccountType ? parseInt(eAppAccountType) : RA_USER;
  288.     
  289.     // rarely used fields
  290.     rule.OutConditionAND = iOutConditionAND ? parseInt(iOutConditionAND) : 0;
  291.     rule.OutConditionOR = iOutConditionOR ? parseInt(iOutConditionOR) : 0;
  292.     // don't really know the TimeOfDay format....
  293.     rule.TimeOfDayType = strDayTimeID ? RT_DEFINITION : RT_DIRECT;
  294.     rule.TimeOfDay = strDayTimeID ? strDayTimeID : (strDayTime ? strDayTime : "");
  295.     rule.Assignment = strUsers ? strUsers : "*";  
  296.     rule.Enabled = !(parseBoolean(bDisabled));
  297.     rule.Preferred = parseBoolean(bPreferred);
  298.     rule.OSVersion = eOSVersion ? parseInt(eOSVersion) : OSVER_WIN_ALL;
  299. }
  300.  
  301. ///////////////////////////////////////////////////////////////////////
  302. // WS_UpdateRuleImpl
  303. //    returns SUCCESS or error code
  304. //
  305. function WS_UpdateRuleImpl( strRuleID, strObjectID, strObject, eObjectType, bIsDllObject, 
  306.     strAppGroupID, strAppLabel, eAppAccountType, 
  307.     iAccessType1, iAccessResult1, iAuditLevel1,  
  308.     iAccessType2, iAccessResult2, iAuditLevel2,  
  309.     iAccessType3, iAccessResult3, iAuditLevel3,  
  310.     iAccessType4, iAccessResult4, iAuditLevel4,  
  311.     iAccessType5, iAccessResult5, iAuditLevel5,  
  312.     iAccessType6, iAccessResult6, iAuditLevel6,  
  313.     iAccessType7, iAccessResult7, iAuditLevel7,  
  314.     iAccessType8, iAccessResult8, iAuditLevel8,  
  315.     strRuleDescription, bHighPriority, bPreferred, bDisabled, bUseClientParser, 
  316.     strUsers, strDayTimeID, strDayTime, iOutConditionAND, iOutConditionOR, eOSVersion, 
  317.     bAvoidSavingSDB )
  318. {
  319.     try {
  320.         var ruleList = getRuleList( bUseClientParser );
  321.         var rule = ruleList.Get(strRuleID);
  322.         if (!rule)
  323.             return ErrorHandler( ERR_EDIT_WS_RULE_FAILED, STR_EDIT_WS_RULE_FAILED );
  324.             
  325.         rule.AccessDescriptorList.Clear();
  326.         
  327.         fillRuleImpl( rule, strObjectID, strObject, eObjectType, bIsDllObject, 
  328.             strAppGroupID, strAppLabel, eAppAccountType, 
  329.             iAccessType1, iAccessResult1, iAuditLevel1,  
  330.             iAccessType2, iAccessResult2, iAuditLevel2,  
  331.             iAccessType3, iAccessResult3, iAuditLevel3,  
  332.             iAccessType4, iAccessResult4, iAuditLevel4,  
  333.             iAccessType5, iAccessResult5, iAuditLevel5,  
  334.             iAccessType6, iAccessResult6, iAuditLevel6,  
  335.             iAccessType7, iAccessResult7, iAuditLevel7,  
  336.             iAccessType8, iAccessResult8, iAuditLevel8,  
  337.             strRuleDescription, bHighPriority, bPreferred, bDisabled, bUseClientParser, 
  338.             strUsers, strDayTimeID, strDayTime, iOutConditionAND, iOutConditionOR, eOSVersion );
  339.         
  340.         saveWSChanges( bUseClientParser, bAvoidSavingSDB );
  341.             
  342.         return SUCCESS;
  343.         
  344.     } catch(e){
  345.         return ErrorHandler( ERR_EDIT_WS_RULE_FAILED, STR_EDIT_WS_RULE_FAILED );
  346.     }
  347. }
  348.  
  349. ///////////////////////////////////////////////////////////////////////
  350. // WS_AddRuleImpl
  351. //    returns strRuleID or "" on error
  352. //
  353. function WS_AddRuleImpl( strObjectID, strObject, eObjectType, bIsDllObject, 
  354.     strAppGroupID, strAppLabel, eAppAccountType, 
  355.     iAccessType1, iAccessResult1, iAuditLevel1,  
  356.     iAccessType2, iAccessResult2, iAuditLevel2,  
  357.     iAccessType3, iAccessResult3, iAuditLevel3,  
  358.     iAccessType4, iAccessResult4, iAuditLevel4,  
  359.     iAccessType5, iAccessResult5, iAuditLevel5,  
  360.     iAccessType6, iAccessResult6, iAuditLevel6,  
  361.     iAccessType7, iAccessResult7, iAuditLevel7,  
  362.     iAccessType8, iAccessResult8, iAuditLevel8,  
  363.     strRuleDescription, bHighPriority, bPreferred, bDisabled, bUseClientParser, 
  364.     strUsers, strDayTimeID, strDayTime, iOutConditionAND, iOutConditionOR, eOSVersion, 
  365.     bAvoidSavingSDB )
  366. {
  367.     try {
  368.         var ruleList = getRuleList( bUseClientParser );
  369.         var newRule = ruleList.CreateRule();
  370.         
  371.         // generate the RuleID => must be unique and must maintain server/client syntax
  372.         newRule.RuleID = ruleList.GenerateRuleID( parseInt(eObjectType), !parseBoolean(bUseClientParser));
  373.         // newRule.RuleIDString is created automatically when newRule.RuleID is set 
  374.         
  375.         fillRuleImpl( newRule, strObjectID, strObject, eObjectType, bIsDllObject, 
  376.             strAppGroupID, strAppLabel, eAppAccountType, 
  377.             iAccessType1, iAccessResult1, iAuditLevel1,  
  378.             iAccessType2, iAccessResult2, iAuditLevel2,  
  379.             iAccessType3, iAccessResult3, iAuditLevel3,  
  380.             iAccessType4, iAccessResult4, iAuditLevel4,  
  381.             iAccessType5, iAccessResult5, iAuditLevel5,  
  382.             iAccessType6, iAccessResult6, iAuditLevel6,  
  383.             iAccessType7, iAccessResult7, iAuditLevel7,  
  384.             iAccessType8, iAccessResult8, iAuditLevel8,  
  385.             strRuleDescription, bHighPriority, bPreferred, bDisabled, bUseClientParser, 
  386.             strUsers, strDayTimeID, strDayTime, iOutConditionAND, iOutConditionOR, eOSVersion );
  387.                 
  388.         var strRuleID = newRule.RuleIDString;
  389.             
  390.         ruleList.Insert(newRule, newRule);
  391.         
  392.         saveWSChanges( bUseClientParser, bAvoidSavingSDB );
  393.             
  394.         return strRuleID;
  395.         
  396.     } catch(e){
  397.         ErrorHandler( ERR_ADDING_WS_RULE_FAILED, STR_ADDING_WS_RULE_FAILED ); 
  398.         return "";
  399.     }
  400. }
  401.  
  402. function WS_CopyRule( strSrcRuleID, bUseClientParser, bAvoidSavingSDB )
  403. {
  404.     try {
  405.         var ruleList = getRuleList( bUseClientParser );
  406.         var rule = ruleList.CreateRule();    
  407.         
  408.         var srcRule = ruleList.Get(strSrcRuleID);
  409.         
  410.         // generate the RuleID => must be unique and must maintain server/client syntax
  411.         rule.RuleID = ruleList.GenerateRuleID( srcRule.ObjectType, !parseBoolean(bUseClientParser));
  412.         // newRule.RuleIDString is created automatically when newRule.RuleID is set 
  413.         
  414.         rule.ObjectType = srcRule.ObjectType;
  415.         rule.PathType = srcRule.PathType;
  416.         rule.Path = srcRule.Path;
  417.         rule.DllObject = srcRule.DllObject;
  418.     
  419.         rule.Application = srcRule.Application;
  420.         rule.AppType = srcRule.AppType;
  421.         rule.Priority = srcRule.Priority;
  422.         rule.Description = srcRule.Description;
  423.             
  424.         rule.Account = srcRule.Account;
  425.         
  426.         // rarely used fields
  427.         rule.OutConditionAND = srcRule.OutConditionAND;
  428.         rule.OutConditionOR = srcRule.OutConditionOR;
  429.         
  430.         // don't really know the TimeOfDay format....
  431.         rule.TimeOfDayType = srcRule.TimeOfDayType;
  432.         rule.TimeOfDay = srcRule.TimeOfDay;
  433.         rule.Assignment = srcRule.Assignment;  
  434.         rule.Enabled = srcRule.Enabled;
  435.         rule.Preferred = srcRule.Preferred;
  436.         rule.OSVersion = srcRule.OSVersion;
  437.             
  438.         rule.AccessDescriptorList.Clear();
  439.     
  440.         //////////////////////////
  441.         var accDescEnum = new Enumerator(srcRule.AccessDescriptorList);
  442.         accDescEnum.moveFirst();
  443.     
  444.         while (!accDescEnum.atEnd())
  445.         {
  446.             var accDesc = accDescEnum.item();
  447.             
  448.             var accessDescriptor = rule.AccessDescriptorList.CreateAccessDescriptor();
  449.  
  450.             accessDescriptor.AccessType = accDesc.AccessType; 
  451.             accessDescriptor.AuditLevel = accDesc.AuditLevel; 
  452.             accessDescriptor.AccessResult = accDesc.AccessResult;         
  453.                         
  454.             rule.AccessDescriptorList.Insert(accessDescriptor);
  455.                     
  456.             accDescEnum.moveNext();
  457.         }    
  458.         ///////////////////////////
  459.     
  460.         var strRuleID = rule.RuleIDString;
  461.  
  462.         ruleList.Insert(rule, rule);
  463.         
  464.         saveWSChanges( bUseClientParser, bAvoidSavingSDB );
  465.  
  466.         return strRuleID;
  467.         
  468.     } catch(e){
  469.         ErrorHandler( ERR_ADDING_WS_RULE_FAILED, STR_ADDING_WS_RULE_FAILED ); 
  470.         return "";
  471.     }
  472. }
  473.  
  474. function WS_MoveRuleToServerDB( strSrcRuleID, bHighPriority )
  475. {
  476.     try {
  477.         var ruleList = getRuleList( true );
  478.         var srcRule = ruleList.Get(strSrcRuleID);
  479.         
  480.         var ruleList = getRuleList( false );
  481.         var rule = ruleList.CreateRule();    
  482.         
  483.         // generate the RuleID => must be unique and must maintain server/client syntax
  484.         rule.RuleID = ruleList.GenerateRuleID( srcRule.ObjectType, true);
  485.         // newRule.RuleIDString is created automatically when newRule.RuleID is set 
  486.         
  487.         rule.ObjectType = srcRule.ObjectType;
  488.         rule.PathType = srcRule.PathType;
  489.         rule.Path = srcRule.Path;
  490.         rule.DllObject = srcRule.DllObject;
  491.     
  492.         rule.Application = srcRule.Application;
  493.         rule.AppType = srcRule.AppType;
  494.         rule.Priority = parseBoolean(bHighPriority) ? PRIOR_HIGH : PRIOR_LOW; 
  495.         rule.Description = srcRule.Description;
  496.             
  497.         rule.Account = srcRule.Account;
  498.         
  499.         // rarely used fields
  500.         rule.OutConditionAND = srcRule.OutConditionAND;
  501.         rule.OutConditionOR = srcRule.OutConditionOR;
  502.         
  503.         // don't really know the TimeOfDay format....
  504.         rule.TimeOfDayType = srcRule.TimeOfDayType;
  505.         rule.TimeOfDay = srcRule.TimeOfDay;
  506.         rule.Assignment = srcRule.Assignment;  
  507.         rule.Enabled = srcRule.Enabled;
  508.         rule.Preferred = srcRule.Preferred;
  509.         rule.OSVersion = srcRule.OSVersion;
  510.             
  511.         rule.AccessDescriptorList.Clear();
  512.     
  513.         //////////////////////////
  514.         var accDescEnum = new Enumerator(srcRule.AccessDescriptorList);
  515.         accDescEnum.moveFirst();
  516.     
  517.         while (!accDescEnum.atEnd())
  518.         {
  519.             var accDesc = accDescEnum.item();
  520.             
  521.             var accessDescriptor = rule.AccessDescriptorList.CreateAccessDescriptor();
  522.  
  523.             accessDescriptor.AccessType = accDesc.AccessType; 
  524.             accessDescriptor.AuditLevel = accDesc.AuditLevel; 
  525.             accessDescriptor.AccessResult = accDesc.AccessResult;         
  526.                         
  527.             rule.AccessDescriptorList.Insert(accessDescriptor);
  528.                     
  529.             accDescEnum.moveNext();
  530.         }    
  531.         ///////////////////////////
  532.     
  533.         var strRuleID = rule.RuleIDString;
  534.  
  535.         ruleList.Insert(rule, rule);
  536.         
  537.         WS_DeleteRule( strSrcRuleID, true, false )
  538.         
  539.         saveWSChanges( true, false );
  540.         saveWSChanges( false, false );
  541.  
  542.         return strRuleID;
  543.         
  544.     } catch(e){
  545.         ErrorHandler( ERR_ADDING_WS_RULE_FAILED, STR_ADDING_WS_RULE_FAILED ); 
  546.         return "";
  547.     }
  548. }
  549.  
  550. ///////////////////////////////////////////////////////////////////////
  551. // WS_DeleteRule
  552. function WS_DeleteRule( strRuleID, bUseClientParser, bAvoidSavingSDB )
  553. {
  554.     try {
  555.         var ruleList = getRuleList( bUseClientParser );
  556.         var rule = ruleList.Get(strRuleID);
  557.         if (rule)
  558.             ruleList.Remove(rule);
  559.             
  560.         saveWSChanges( bUseClientParser, bAvoidSavingSDB );
  561.         return SUCCESS;
  562.     } catch(e){
  563.         return ErrorHandler( ERR_DELETE_WS_RULE_FAILED, STR_DELETE_WS_RULE_FAILED ); 
  564.     }
  565. }
  566.  
  567. ///////////////////////////////////////////////////////////////////////
  568. // WS_EnableRule
  569. function WS_EnableRule( strRuleID, bDisable, bUseClientParser, bAvoidSavingSDB )
  570. {
  571.     try {
  572.         
  573.         var ruleList = getRuleList( bUseClientParser );
  574.             
  575.         var rule = ruleList.Get(strRuleID);
  576.         if (rule)
  577.             rule.Enabled = parseBoolean(bDisable) ? false : true;
  578.             
  579.         saveWSChanges( bUseClientParser, bAvoidSavingSDB );
  580.         
  581.         return SUCCESS;
  582.     } catch(e){
  583.         return ErrorHandler( ERR_EDIT_WS_RULE_FAILED, STR_EDIT_WS_RULE_FAILED ); 
  584.     }
  585. }
  586.  
  587. ///////////////////////////////////////////////////////////////////////
  588. // WS_SetTime
  589. function WS_SetTime( strRuleID, strDayTime, strDayTimeID, bUseClientParser, bAvoidSavingSDB )
  590. {
  591.     try {
  592.  
  593.         var ruleList = getRuleList( bUseClientParser );
  594.  
  595.         var rule = ruleList.Get(strRuleID);
  596.         if (rule)
  597.         {
  598.             // don't really know the TimeOfDay format....
  599.             rule.TimeOfDayType = strDayTimeID ? RT_DEFINITION : RT_DIRECT;
  600.             rule.TimeOfDay = strDayTimeID ? strDayTimeID : (strDayTime ? strDayTime : "");
  601.         }
  602.  
  603.         saveWSChanges( bUseClientParser, bAvoidSavingSDB );
  604.         return SUCCESS;
  605.     } catch(e){
  606.         return ErrorHandler( ERR_EDIT_WS_RULE_FAILED, STR_EDIT_WS_RULE_FAILED );
  607.     }
  608. }
  609.  
  610. ///////////////////////////////////////////////////////////////////////
  611. // WS_SetUsers
  612. function WS_SetUsers( strRuleID, strUsers, bUseClientParser, bAvoidSavingSDB )
  613. {
  614.     try {
  615.  
  616.         var ruleList = getRuleList( bUseClientParser );
  617.  
  618.         var rule = ruleList.Get(strRuleID);
  619.         if (rule)
  620.         {
  621.             rule.Assignment = strUsers ? strUsers : "*";  
  622.         }
  623.  
  624.         saveWSChanges( bUseClientParser, bAvoidSavingSDB );
  625.         return SUCCESS;
  626.     } catch(e){
  627.         return ErrorHandler( ERR_EDIT_WS_RULE_FAILED, STR_EDIT_WS_RULE_FAILED );
  628.     }
  629. }
  630.  
  631. ///////////////////////////////////////////////////////////////////////
  632. // WS_SetApp
  633. function WS_SetApp( strRuleID, strAppLabel, strAppGroupID, bUseClientParser, bAvoidSavingSDB )
  634. {
  635.     try {
  636.         var ruleList = getRuleList( bUseClientParser );
  637.  
  638.         var rule = ruleList.Get(strRuleID);
  639.         if (rule)
  640.         {
  641.             rule.Application = strAppGroupID ? strAppGroupID : strAppLabel;
  642.             rule.AppType = strAppGroupID ? AT_DEFINITION : AT_LABEL;
  643.         }
  644.  
  645.         saveWSChanges( bUseClientParser, bAvoidSavingSDB );
  646.         return SUCCESS;
  647.     } catch(e){
  648.         return ErrorHandler( ERR_EDIT_WS_RULE_FAILED, STR_EDIT_WS_RULE_FAILED );
  649.     }
  650. }
  651.  
  652. ///////////////////////////////////////////////////////////////////////
  653. // WS_SwitchRulePriority
  654. function WS_SwitchRulePriority( strRuleID, bAvoidSavingSDB )
  655. {
  656.     try {
  657.     
  658.         var ruleList = getRuleList( false );
  659.         
  660.         var rule = ruleList.Get(strRuleID);
  661.         if (rule)
  662.             rule.Priority = (rule.Priority == PRIOR_LOW) ? PRIOR_HIGH : PRIOR_LOW;
  663.             
  664.         saveWSChanges( false, bAvoidSavingSDB );
  665.         return SUCCESS;
  666.     } catch(e){
  667.         return ErrorHandler( ERR_EDIT_WS_RULE_FAILED, STR_EDIT_WS_RULE_FAILED ); 
  668.     }
  669. }
  670.  
  671.  
  672. ///////////////////////////////////////////////////////////////////////
  673. // WS_SetRulePreferred
  674. function WS_SetRulePreferred( strRuleID, bPreferred, bAvoidSavingSDB )
  675. {
  676.     try {
  677.     
  678.         var ruleList = getRuleList( false );
  679.         
  680.         var rule = ruleList.Get(strRuleID);
  681.         if (rule)
  682.             rule.Preferred = bPreferred;
  683.             
  684.         saveWSChanges( false, bAvoidSavingSDB );
  685.         return SUCCESS;
  686.     } catch(e){
  687.         return ErrorHandler( ERR_EDIT_WS_RULE_FAILED, STR_EDIT_WS_RULE_FAILED ); 
  688.     }
  689. }
  690.  
  691.  
  692. ///////////////////////////////////////////////////////////////////////
  693. // WS_SetRulePriority
  694. function WS_SetRulePriority( strRuleID, bHighPriority, bAvoidSavingSDB )
  695. {
  696.     try {
  697.     
  698.         var ruleList = getRuleList( false );
  699.         
  700.         var rule = ruleList.Get(strRuleID);
  701.         if (rule)
  702.             rule.Priority = (bHighPriority) ? PRIOR_HIGH : PRIOR_LOW;
  703.             
  704.         saveWSChanges( false, bAvoidSavingSDB );
  705.         return SUCCESS;
  706.     } catch(e){
  707.         return ErrorHandler( ERR_EDIT_WS_RULE_FAILED, STR_EDIT_WS_RULE_FAILED ); 
  708.     }
  709. }
  710.  
  711. ///////////////////////////////////////////////////////////////////////
  712. // WS_SetRuleAccount
  713. function WS_SetRuleAccount( strRuleID, eSystemAccountType, bAvoidSavingSDB )
  714. {
  715.     try {
  716.         var ruleList = getRuleList( false );
  717.         
  718.         var rule = ruleList.Get(strRuleID);
  719.         if (rule)
  720.             rule.Account = parseInt(eSystemAccountType);
  721.             
  722.         saveWSChanges( false, bAvoidSavingSDB );
  723.         return SUCCESS;
  724.     } catch(e){
  725.         return ErrorHandler( ERR_EDIT_WS_RULE_FAILED, STR_EDIT_WS_RULE_FAILED ); 
  726.     }
  727. }
  728.  
  729. ///////////////////////////////////////////////////////////////////////
  730. // WS_SetObject 
  731. function WS_SetObject(strRuleID, eObjectType, strObjectID, strObject, bIsDllObject, bUseClientParser, bAvoidSavingSDB)
  732. {
  733.     try {
  734.         var ruleList = getRuleList( bUseClientParser );
  735.         
  736.         var rule = ruleList.Get(strRuleID);
  737.         if (rule)
  738.         {
  739.             rule.ObjectType = parseInt(eObjectType);
  740.             rule.PathType = strObjectID ? RT_DEFINITION : RT_DIRECT;
  741.             rule.Path = strObjectID ? strObjectID : (strObject ? strObject : "");
  742.             rule.DllObject = parseBoolean(bIsDllObject);
  743.         }
  744.             
  745.         saveWSChanges( bUseClientParser, bAvoidSavingSDB );
  746.         return SUCCESS;
  747.     } catch(e){
  748.         return ErrorHandler( ERR_EDIT_WS_RULE_FAILED, STR_EDIT_WS_RULE_FAILED ); 
  749.     }
  750. }
  751.  
  752. ///////////////////////////////////////////////////////////////////////
  753. // getAllAccessTypes - internal function, used in WS_SetRuleAccess
  754. function getAllAccessTypes( eObjectType )
  755. {
  756.     switch ( eObjectType )
  757.     {
  758.         case OT_FILE:
  759.             return STR_FILE_ACCESS_TYPE_IDS.split("|");
  760.         case OT_REGISTRY:
  761.             return STR_REGISTRY_ACCESS_TYPE_IDS.split("|");
  762.         case OT_SERVICE:
  763.             return STR_SERVICE_ACCESS_TYPE_IDS.split("|");
  764.         case OT_COMOBJECT:
  765.             return STR_OLECOM_ACCESS_TYPE_IDS.split("|");
  766.         case OT_SPAWNING:
  767.             return STR_SPAWNING_ACCESS_TYPE_IDS.split("|");
  768.         case OT_SPAWN_DLL:
  769.             return STR_DLLLOAD_ACCESS_TYPE_IDS.split("|");
  770.         case OT_SYSTEMPRIV:
  771.             return STR_SYSPRIV_ACCESS_TYPE_IDS.split("|");
  772.         case OT_DEVICE:
  773.             return STR_DEVICE_ACCESS_TYPE_IDS.split("|");
  774.         default:
  775.             return 0;
  776.     }
  777. }
  778.  
  779. ///////////////////////////////////////////////////////////////////////
  780. // getFullAccessMask - internal function, used in WS_SetRuleAccess
  781. function getFullAccessMask( arrStrAT )
  782. {
  783.     var iResult = 0;
  784.     
  785.     var i = 0;
  786.     for (i = 0; i < arrStrAT.length; i++)
  787.         iResult += parseInt(arrStrAT[i]);
  788.     
  789.     return iResult;
  790. }
  791.  
  792. ///////////////////////////////////////////////////////////////////////
  793. // WS_SetRuleAccess
  794. function WS_SetRuleAccess( strRuleID, iAccessType, iAccessResult, iAuditLevel, bUseClientParser, bAvoidSavingSDB )
  795. {
  796.     try {
  797.         //alert( strRuleID + ", " + iAccessType + ", " + iAccessResult + ", " + iAuditLevel )
  798.         //alert( iAccessType )
  799.         //alert( iAccessResult )
  800.         //alert( iAuditLevel )
  801.         //alert( bUseClientParser )
  802.         //alert( bAvoidSavingSDB )
  803.         
  804.         var ruleList = getRuleList( bUseClientParser );
  805.         var rule = ruleList.Get(strRuleID);
  806.         if (rule)
  807.         {
  808.             var arrStrAT = getAllAccessTypes( rule.ObjectType );
  809.             
  810.             var accDescEnum = new Enumerator(rule.AccessDescriptorList);
  811.             accDescEnum.moveFirst();
  812.  
  813.             while (!accDescEnum.atEnd())
  814.             {
  815.                 var accDesc = accDescEnum.item();
  816.                 
  817.                 // check, if access type is '*'
  818.                 if (arrStrAT && accDesc.AccessType == getFullAccessMask( arrStrAT )) 
  819.                 {    // if it is, then clear remove it from rule and create separate
  820.                     //  AccessDescriptors for each individual access type
  821.                 
  822.                     var prevAR = accDesc.AccessResult;
  823.                     var prevAL = accDesc.AuditLevel;
  824.                     
  825.                     rule.AccessDescriptorList.Clear();
  826.                     
  827.                     var i = 0;
  828.                     for (i = 0; i < arrStrAT.length; i++)
  829.                     {
  830.                         if (parseInt(arrStrAT[i]) != iAccessType) // skip iAccessType this fnc is called for
  831.                             WS_AddAccesDescriptorToRuleImpl( rule, parseInt(arrStrAT[i]), prevAR, prevAL );
  832.                     }
  833.                     
  834.                     // finally add the access type this fnc is called for
  835.                     if (typeof(iAuditLevel) != "number")
  836.                         iAuditLevel = prevAL;
  837.                     if (typeof(iAccessResult) != "number")
  838.                         iAccessResult = prevAR;
  839.                         
  840.                     WS_AddAccesDescriptorToRuleImpl( rule, iAccessType, iAccessResult, iAuditLevel );
  841.  
  842.                     saveWSChanges( bUseClientParser, bAvoidSavingSDB );
  843.                     return SUCCESS; 
  844.                 }
  845.                 
  846.                 // check if this is the access type we want to change
  847.                 if (accDesc.AccessType == iAccessType) 
  848.                 {
  849.                     if (typeof(iAccessResult) == "number")
  850.                         accDesc.AccessResult = iAccessResult ? parseInt(iAccessResult) : 0;
  851.                     if (typeof(iAuditLevel) == "number")
  852.                         accDesc.AuditLevel = iAuditLevel ? parseInt(iAuditLevel) : 0;
  853.                         
  854.                     saveWSChanges( bUseClientParser, bAvoidSavingSDB );
  855.                     return SUCCESS;
  856.                 }
  857.                 accDescEnum.moveNext();
  858.             }
  859.             
  860.             if (typeof(iAuditLevel) != "number")
  861.                 iAuditLevel = AL_IGNORE;
  862.                 
  863.             if (typeof(iAccessResult) != "number")
  864.                 iAccessResult = AR_ALLOW;                
  865.                         
  866.             WS_AddAccesDescriptorToRuleImpl( rule, iAccessType, iAccessResult, iAuditLevel );
  867.         }
  868.             
  869.         saveWSChanges( bUseClientParser, bAvoidSavingSDB );
  870.         return SUCCESS;
  871.     } catch(e){
  872.         //alert( "exception: " + e)
  873.         return ErrorHandler( ERR_EDIT_WS_RULE_FAILED, STR_EDIT_WS_RULE_FAILED ); 
  874.     }
  875. }
  876.  
  877. ///////////////////////////////////////////////////////////////////////
  878. // WS_AddPredefinedObject
  879. function WS_AddPredefinedObject( strObjectID, eObjectType, strPath, bUseClientParser, bAvoidSavingSDB )
  880. {
  881.     try {
  882.         var definitionList = getDefinitionList( bUseClientParser ); 
  883.         var definition = definitionList.CreateDefinition();
  884.         
  885.         definition.DefinitionID = strObjectID;
  886.         definition.ObjectType = parseInt(eObjectType);
  887.         
  888.         if (strPath)
  889.         {
  890.             var newItem = definition.ItemList.CreateItem();
  891.             newItem.Content = strPath;
  892.             definition.ItemList.Insert(newItem);
  893.         }
  894.         
  895.         definitionList.Insert( definition );
  896.         
  897.         saveWSChanges( bUseClientParser, bAvoidSavingSDB );
  898.         
  899.         return SUCCESS;
  900.     }
  901.     catch(e) {
  902.         return ErrorHandler( ERR_ADDING_WS_OBJECT_FAILED, STR_ADDING_WS_OBJECT_FAILED ); 
  903.     }
  904. }
  905.  
  906. function WS_getDefinition( strObjectID, bUseClientParser )
  907. {
  908.     var defList = getDefinitionList( bUseClientParser );
  909.  
  910.     try
  911.     {
  912.         return defList.Get( strObjectID );
  913.     }
  914.     catch (e)
  915.     {
  916.         return null;
  917.     }
  918. }
  919.  
  920. function WS_isObjNameUnique( strObjectID, bUseClientParser )
  921. {
  922.     var defList = getDefinitionList( bUseClientParser );
  923.  
  924.     try
  925.     {
  926.         var definition = defList.Get( strObjectID );
  927.         return false;
  928.     }
  929.     catch (e)
  930.     {
  931.         return true;
  932.     }
  933. }
  934.  
  935. ///////////////////////////////////////////////////////////////////////
  936. // WS_DeletePredefinedObject 
  937. function WS_DeletePredefinedObject( strObjectID, bUseClientParser, bAvoidSavingSDB )
  938. {
  939.     // remove it from WS database
  940.     try {
  941.         var definitionList = getDefinitionList( bUseClientParser );
  942.         
  943.         var definition = definitionList.Get( strObjectID );
  944.         if (definition)
  945.             definitionList.Remove(definition);
  946.             
  947.         saveWSChanges( bUseClientParser, bAvoidSavingSDB );
  948.         
  949.         return SUCCESS;
  950.     }
  951.     catch(e) {
  952.         return ErrorHandler( ERR_DELETE_WS_OBJECT_FAILED, STR_DELETE_WS_OBJECT_FAILED ); 
  953.     }
  954. }
  955.  
  956. ///////////////////////////////////////////////////////////////////////
  957. // WS_AddPathToPredefinedObject
  958. function WS_AddPathToPredefinedObject( strObjectID, strPath, bUseClientParser, bAvoidSavingSDB )
  959. {
  960.     try {
  961.         var definitionList = getDefinitionList( bUseClientParser );
  962.         var definition = definitionList.Get( strObjectID );
  963.         var newItem = definition.ItemList.CreateItem();
  964.         newItem.Content = strPath;
  965.         definition.ItemList.Insert(newItem);
  966.         
  967.         saveWSChanges( bUseClientParser, bAvoidSavingSDB );
  968.         
  969.         return SUCCESS;
  970.     }
  971.     catch(e) {
  972.         return ErrorHandler( ERR_EDIT_WS_OBJECT_FAILED, STR_EDIT_WS_OBJECT_FAILED ); 
  973.     }
  974. }
  975.  
  976. ///////////////////////////////////////////////////////////////////////
  977. // WS_RemovePathFromPredefinedObject
  978. function WS_RemovePathFromPredefinedObject( strObjectID, strPath, bUseClientParser, bAvoidSavingSDB )
  979. {
  980.     try {
  981.         var definitionList = getDefinitionList( bUseClientParser );
  982.         var definition = definitionList.Get( strObjectID );
  983.  
  984.         var itemEnum = new Enumerator(definition.ItemList);
  985.         itemEnum.moveFirst();
  986.                 
  987.         while (!itemEnum.atEnd())
  988.         {
  989.             var item = itemEnum.item();
  990.             if (item.Content == strPath)
  991.             {
  992.                 definition.ItemList.Remove(item);
  993.                 break;
  994.             }
  995.             itemEnum.moveNext();
  996.         }
  997.             
  998.         saveWSChanges( bUseClientParser, bAvoidSavingSDB );
  999.         
  1000.         return SUCCESS;
  1001.     }
  1002.     catch(e) {
  1003.         return ErrorHandler( ERR_EDIT_WS_OBJECT_FAILED, STR_EDIT_WS_OBJECT_FAILED ); 
  1004.     }
  1005. }
  1006.  
  1007. ///////////////////////////////////////////////////////////////////////
  1008. // WS_GetPredefinedObjectEnumerator
  1009. function WS_GetPredefinedObjectEnumerator( strObjectID, bUseClientParser )
  1010. {
  1011.     try {
  1012.         var definitionList = getDefinitionList( bUseClientParser );
  1013.         var definition = definitionList.Get( strObjectID );
  1014.  
  1015.         return new Enumerator(definition.ItemList);
  1016.     }
  1017.     catch(e) {
  1018.         return null; 
  1019.     }
  1020. }
  1021.  
  1022. function WS_GetPredefinedObject( strObjectID, bUseClientParser )
  1023. {
  1024.     try {
  1025.         var definitionList = getDefinitionList( bUseClientParser );
  1026.         var definition = definitionList.Get( strObjectID );
  1027.  
  1028.         return definition;
  1029.     }
  1030.     catch(e) {
  1031.         return null; 
  1032.     }
  1033. }
  1034.  
  1035.  
  1036. ///////////////////////////////////////////////////////////////////////
  1037. // WS_ClearAllPredefinedObjectContent
  1038. function WS_ClearAllPredefinedObjectContent( strObjectID, bUseClientParser, bAvoidSavingSDB )
  1039. {
  1040.     try {
  1041.         var definitionList = getDefinitionList( bUseClientParser );
  1042.         var definition = definitionList.Get( strObjectID );
  1043.         
  1044.         definition.ItemList.Clear();
  1045.                 
  1046.         saveWSChanges( bUseClientParser, bAvoidSavingSDB );
  1047.         
  1048.         return SUCCESS;
  1049.     }
  1050.     catch(e) {
  1051.         return ErrorHandler( ERR_EDIT_WS_OBJECT_FAILED, STR_EDIT_WS_OBJECT_FAILED ); 
  1052.     }
  1053. }
  1054.  
  1055.  
  1056. ///////////////////////////////////////////////////////////////////////
  1057. // WS_AddException
  1058. function WS_AddException( iGuardsMask, strAppGroupID, strAppLabel, eAppAccountType, bHighPriority, strUsers, bAvoidSavingSDB )
  1059. {
  1060.     try {
  1061.         var exceptionList = getAppExceptionList(); 
  1062.         var wsexception = exceptionList.CreateAppException();
  1063.         
  1064.         wsexception.AppType = strAppGroupID ? AT_DEFINITION : AT_LABEL;
  1065.         wsexception.Application = strAppGroupID ? strAppGroupID : strAppLabel;
  1066.         wsexception.ActiveGuards = parseInt(iGuardsMask);
  1067.         wsexception.Priority = parseBoolean(bHighPriority) ? PRIOR_HIGH : PRIOR_LOW; 
  1068.         wsexception.Account = parseInt(eAppAccountType); 
  1069.         wsexception.Assignment = strUsers ? strUsers : "*"; 
  1070.         
  1071.         exceptionList.Insert( wsexception );
  1072.         
  1073.         saveWSChanges( false, bAvoidSavingSDB );
  1074.         
  1075.         return SUCCESS;
  1076.     }
  1077.     catch(e) {
  1078.         return ErrorHandler( ERR_ADDING_WS_OBJECT_FAILED, STR_ADDING_WS_OBJECT_FAILED ); 
  1079.     }
  1080. }
  1081.  
  1082. ///////////////////////////////////////////////////////////////////////
  1083. // WS_DeleteException 
  1084. function WS_DeleteException( strAppGroupID, strAppLabel, eAppAccountType, bHighPriority, strUsers, bAvoidSavingSDB )
  1085. {
  1086.     // remove it from WS database
  1087.     try {
  1088.         var exceptionList = getAppExceptionList(); 
  1089.         
  1090.         var strApp = strAppGroupID ? strAppGroupID : strAppLabel;
  1091.         var Account = parseInt(eAppAccountType); 
  1092.         var Priority = parseBoolean(bHighPriority) ? PRIOR_HIGH : PRIOR_LOW; 
  1093.         if (!strUsers)
  1094.             strUsers = "*";
  1095.         
  1096.         var excListEnum = new Enumerator(exceptionList);
  1097.         excListEnum.moveFirst();
  1098.  
  1099.         while (!excListEnum.atEnd())
  1100.         {
  1101.             var wsexception = excListEnum.item();
  1102.             if (wsexception.Application == strApp && wsexception.Account == Account && wsexception.Priority == Priority && wsexception.Assignment == strUsers) 
  1103.             {
  1104.                 exceptionList.Remove(wsexception);
  1105.                 break;
  1106.             }
  1107.             excListEnum.moveNext();
  1108.         }
  1109.  
  1110.         saveWSChanges( false, bAvoidSavingSDB );
  1111.         
  1112.         return SUCCESS;
  1113.     }
  1114.     catch(e) {
  1115.         return ErrorHandler( ERR_DELETE_WS_OBJECT_FAILED, STR_DELETE_WS_OBJECT_FAILED ); 
  1116.     }
  1117. }
  1118.  
  1119. ///////////////////////////////////////////////////////////////////////
  1120. // WS_GetPropertyValue 
  1121. function WS_GetPropertyValue( strPropertyID )
  1122. {
  1123.     try {
  1124.         var propList = getGlobalOptions();
  1125.         var prop = propList.Get( strPropertyID );
  1126.         return prop.Value;
  1127.     } catch(e) {
  1128.         return "";
  1129.     }
  1130. }
  1131.  
  1132. ///////////////////////////////////////////////////////////////////////
  1133. // WS_SetPropertyValue     
  1134. function WS_SetPropertyValue( strPropertyID, Value, eType, bAvoidSavingSDB )
  1135. {
  1136.     var propList = null;
  1137.     try {
  1138.         propList = getGlobalOptions();
  1139.     } catch(e) {
  1140.         return ErrorHandler( ERR_EDIT_SBX_PROPERTY_FAILED, STR_EDIT_SBX_PROPERTY_FAILED ); 
  1141.     }
  1142.     
  1143.     var prop = null;
  1144.     try {
  1145.         prop = propList.Get( strPropertyID );
  1146.     } catch(e) {
  1147.     }
  1148.     
  1149.     try {
  1150.         
  1151.         if (!prop)
  1152.         {
  1153.             prop = propList.CreateProperty();
  1154.             prop.Type = eType;
  1155.             prop.PropertyID = strPropertyID;
  1156.             propList.Insert(prop);
  1157.         }
  1158.         switch ( parseInt(eType) )
  1159.         {
  1160.             case PT_INT:
  1161.                 prop.Value = parseInt(Value);
  1162.                 break;
  1163.             case PT_BOOL:
  1164.                 prop.Value = parseBoolean(Value);
  1165.                 break;
  1166.             default:
  1167.                 prop.Value = Value;
  1168.  
  1169.         }
  1170.         
  1171.         saveWSChanges( false, bAvoidSavingSDB );
  1172.         return SUCCESS;
  1173.     } catch(e) {
  1174.         return ErrorHandler( ERR_EDIT_SBX_PROPERTY_FAILED, STR_EDIT_SBX_PROPERTY_FAILED ); 
  1175.     }
  1176. }
  1177.  
  1178.